<template>
	<view class="shangc-box">
		<view class="shangc-neir">
			<label>
				名称:
			</label>
			<input type="text" v-model="sourceIndex" placeholder="请输入名称">

		</view>

		<view class="shangc-neir" v-for="(item,index) in arrcont" :key="index">
			<label :for="item.id">
				{{item.name}}
			</label>
			<input type="text" :id="item.id" :type="item.type" :placeholder="'请输入'  + item.name" v-model="item.text"
				name="">
			<view class="" v-show="item.yuan">
				元
			</view>
		</view>
		<view class="shangc-neir" @click="showType">
			<view>分类</view>
			<picker style="flex: 1;text-align: center;" mode="multiSelector" :range="pickerRange" :value="pickerValue"
				@change="unpType" @cancel="onCancel" @columnchange='onChange'>
				<view class="">
					{{selectedMain}}
				</view>
			</picker>
		</view>


		<view class="shangc-neir">
			<picker mode="selector" :range="kouan" @change="kouanadd">
				<view class="picker">
					<view class="">
						扣眼
					</view>
					<view class="juzhong">
						{{kouan[kouanIndex]}}
					</view>
				</view>
			</picker>
		</view>

		<view class="shangc-neir">
			<label>
				模式
			</label>
			<input type="number" v-model="moshidL" :readonly="isInputReadonly" placeholder="请输入时间">
		</view>




		<view class="shangc-neir">
			<label>
				时间
			</label>
			<input type="digit" v-model="dataTime" :readonly="isInputReadonly" placeholder="请输入时间">
		</view>


		<view class="camera-container">
			<camera id="camera" device-position="back" flash="auto" binderror="onError" 
				style="width: 500rpx; height: 500rpx;  filter: brightness(1.5)" />
		</view>

		<scroll-view scroll-y="true" style="min-height: 50rpx;" :scroll-into-view="toView" class="image-grid-scroll">
			<view class="image-grid">
				<view class="grid-item" v-for="(item, index) in ListImags" :key="index" :id="'img'+index">
					<image :src="item" mode="aspectFill" />
					<view class="delete-btn" @click="deleteImage(index)">删除</view>
				</view>
			</view>
		</scroll-view>


		<view class="unpdata" @click="paizhao()">
			开始拍照
		</view>
		<view class="unpdata" @click="tingpaizhao()">
			停止拍照
		</view>

		<view class="unpdata" @click="unpdflin">
			新增商品
		</view>


		<canvas canvas-id="myCanvas"
			style="width: 300px; height: 300px; opacity: 0; position: absolute; left: -9999px; z-index: -1;"></canvas>
	</view>
</template>

<script>
	import api from '../../api/Channel.js'
	import commonMixin from '@/mixins/qiLiuyun.js';
	import request from '../../api/index.js'
	import suffixAddress from '../../api/suffixAddress.js'
	export default {
		mixins: [commonMixin],
		data() {
			return {
				arrcont: [{
					name: '大小',
					text: null,
					type: 'text',
					hou: '元',
					id: 2
				}],
				arrimgas: [],
				qiniuyunImage: [],
				showPicker: true, // 控制picker显示隐藏
				pickerValue: [0, 0], // 当前选中索引 [主分类索引, 子分类索引]
				categories: [],
				pickerRange: [
					[],
					[]
				], // picker需要的二维数组 [[主分类数组], [子分类数组]]
				selectedMain: '请选择分类',
				selectedSub: '',
				commodities: [],
				categoryId: null,
				options: ['柜台', '仓库 ', '虎门'],
				selectedIndex: 0,
				mos: ['1/20', '2/20', '3/20', '4/20', '5/20', '6/20', '7/20', '8/20', '9/20', '10/20', '11/20', '12/20',
					'13/20', '14/20', '15/20', '16/20', '17/20', '18/20', '19/20', '20/20'
				],
				mosIndex: 0,
				kouan: ['明眼', '暗眼'],
				kouanIndex: 0,
				sourceIndex: '',
				photoPath: '',
				ListImags: [],
				cameraContext: null, // 用于保存相机上下文

				devices: [], // 存储扫描到的设备列表
				isConnected: false, // 是否连接到设备
				connectedDeviceId: "", // 已连接的设备ID
				dataTime: 5.2,
				dataDingshiq: null,
				isInputReadonly: false,
				moshidL: 0
			};
		},
		onLoad() {
			this.acategories()
		},
		mounted() {
			// 页面加载后创建相机上下文
			this.cameraContext = uni.createCameraContext();
		},
		onUnload() {
			// 页面销毁时清理事件监听
			// this.disconnectBluetooth();
			clearInterval(this.dataDingshiq);
		},
		methods: {
			paizhao() {
				uni.showToast({
					title: '开始拍照', // 提示内容
					icon: 'success' // 'success', 'error', 'loading', 'none'
				});
				this.isInputReadonly = true
				this.dataDingshiq = setInterval(() => {
					this.takePhoto()
					uni.pageScrollTo({
						scrollTop: 99999, // 一个很大的值即可
						duration: 300 // 滚动动画时长（毫秒）
					});
					// 可以在这里写轮询蓝牙、刷新页面、倒计时等业务
				}, this.dataTime * 1000);

				// 滚动到页面最底部
			},
			tingpaizhao() {
				clearInterval(this.dataDingshiq);
				this.isInputReadonly = false
				uni.showToast({
					title: '停止成功', // 提示内容
					icon: 'success' // 'success', 'error', 'loading', 'none'
				})
			},
			deleteImage(index) {
				this.ListImags.splice(index, 1)
				uni.showToast({
					title: '删除成功', // 提示内容
					icon: 'success' // 'success', 'error', 'loading', 'none'
				})
			},

			// async openBluetoothAdapteraa() {
			// 	//蓝牙
			// 	let openBluetoothAdapter = await this.openBluetoothAdapter();
			// 	let deviceId = await this.getConnectedDevice()
			// 	let Bluet = await this.getBluetoothServicesAndCharacteristics(deviceId)
			// 	let getNotifyCharacteristicId = await this.getNotifyCharacteristicId(Bluet.deviceId, Bluet.serviceId)
			// 	this.readBleCharacteristicValue(Bluet.deviceId, Bluet.serviceId, Bluet.characteristicId)


			// 	// setInterval(() => {
			// 	// this.readBleCharacteristicValue(Bluet.deviceId, Bluet.serviceId, Bluet.characteristicId)
			// 	// }, 4000);

			// 	// setInterval(() => {
			// 	// 	console.log(this.dataTime)
			// 	// }, this.dataTime);



			// },

			// //蓝牙
			// async openBluetoothAdapteraa() {
			// 	try {
			// 		// 1. 初始化蓝牙
			// 		await this.openBluetoothAdapter();

			// 		// 2. 获取并连接第一个蓝牙设备（可按需改成筛选指定设备）
			// 		const deviceId = await new Promise((resolve, reject) => {
			// 			uni.getBluetoothDevices({
			// 				success: (devicesRes) => {
			// 					if (devicesRes.devices.length > 0) {
			// 						const deviceId = devicesRes.devices[0].deviceId;
			// 						uni.createBLEConnection({
			// 							deviceId: deviceId,
			// 							success: () => resolve(deviceId),
			// 							fail: reject
			// 						});
			// 					} else {
			// 						reject("没有可用的蓝牙设备");
			// 					}
			// 				},
			// 				fail: reject
			// 			});
			// 		});

			// 		// 3. 遍历所有service，找第一个支持read的characteristic
			// 		const {
			// 			serviceId,
			// 			characteristicId
			// 		} = await new Promise((resolve, reject) => {
			// 			uni.getBLEDeviceServices({
			// 				deviceId,
			// 				success: (servicesRes) => {
			// 					let found = false;
			// 					servicesRes.services.forEach(service => {
			// 						uni.getBLEDeviceCharacteristics({
			// 							deviceId,
			// 							serviceId: service.uuid,
			// 							success: (charRes) => {
			// 								const readable = charRes
			// 									.characteristics.find(c => c
			// 										.properties.read);
			// 								if (readable && !found) {
			// 									found = true;
			// 									resolve({
			// 										serviceId: service
			// 											.uuid,
			// 										characteristicId: readable
			// 											.uuid
			// 									});
			// 								}
			// 							}
			// 						});
			// 					});
			// 					setTimeout(() => {
			// 						if (!found) reject('没有可用的read特征值');
			// 					}, 2000);
			// 				},
			// 				fail: reject
			// 			});
			// 		});

			// 		// 4. 只绑定一次监听
			// 		uni.onBLECharacteristicValueChange((res) => {
			// 			const arr = new Uint8Array(res.value);
			// 			console.log('收到蓝牙read数据:', arr);

			// 			// 举例：收到特定数据（如第一个字节为1）自动拍照
			// 			if (arr[0] === 1) {
			// 				this.takePhoto();
			// 			}
			// 		});

			// 		// 5. 启动定时轮询read
			// 		if (this.bleReadTimer) clearInterval(this.bleReadTimer);
			// 		this.bleReadTimer = setInterval(() => {
			// 			uni.readBLECharacteristicValue({
			// 				deviceId,
			// 				serviceId,
			// 				characteristicId,
			// 				success() {},
			// 				fail(err) {
			// 					console.error('读取失败', err);
			// 				}
			// 			});
			// 		}, 1000); // 1秒轮询一次

			// 		uni.showToast({
			// 			title: '蓝牙已开始读取',
			// 			icon: 'success'
			// 		});
			// 	} catch (e) {
			// 		uni.showToast({
			// 			title: String(e),
			// 			icon: 'none'
			// 		});
			// 	}
			// },


			//蓝牙订阅
			// async openBluetoothAdapteraasss() {
			//     try {
			//         // 1. 初始化蓝牙
			//         await this.openBluetoothAdapter();

			//         // 2. 获取并连接第一个蓝牙设备（可按需改成筛选指定设备）
			//         const deviceId = await new Promise((resolve, reject) => {
			//             uni.getBluetoothDevices({
			//                 success: (devicesRes) => {
			//                     if (devicesRes.devices.length > 0) {
			//                         const deviceId = devicesRes.devices[0].deviceId;
			//                         uni.createBLEConnection({
			//                             deviceId: deviceId,
			//                             success: () => resolve(deviceId),
			//                             fail: reject
			//                         });
			//                     } else {
			//                         reject("没有可用的蓝牙设备");
			//                     }
			//                 },
			//                 fail: reject
			//             });
			//         });

			//         // 3. 获取设备服务并查找支持 notify 或 read 的特征值
			//         const { serviceId, characteristicId } = await new Promise((resolve, reject) => {
			//             uni.getBLEDeviceServices({
			//                 deviceId,
			//                 success: (servicesRes) => {
			//                     let found = false;
			//                     servicesRes.services.forEach(service => {
			//                         uni.getBLEDeviceCharacteristics({
			//                             deviceId,
			//                             serviceId: service.uuid,
			//                             success: (charRes) => {
			//                                 // 找到支持 notify 或 read 特征值
			//                                 const notifyOrRead = charRes.characteristics.find(c => c.properties.notify || c.properties.read);
			//                                 if (notifyOrRead && !found) {
			//                                     found = true;
			//                                     resolve({
			//                                         serviceId: service.uuid,
			//                                         characteristicId: notifyOrRead.uuid
			//                                     });
			//                                 }
			//                             }
			//                         });
			//                     });

			//                     setTimeout(() => {
			//                         if (!found) reject('没有可用的notify/read特征值');
			//                     }, 2000);
			//                 },
			//                 fail: reject
			//             });
			//         });

			//         // 4. 订阅特征值的通知
			//         uni.notifyBLECharacteristicValueChange({
			//             deviceId,
			//             serviceId,
			//             characteristicId,
			//             state: true, // 开启通知
			//             success: () => {
			//                 console.log('成功订阅特征值通知');
			//             },
			//             fail: (err) => {
			//                 console.error('订阅失败:', err);
			//             }
			//         });

			//         // 5. 监听特征值变化
			//         uni.onBLECharacteristicValueChange((res) => {
			//             const arr = new Uint8Array(res.value);
			//             console.log('收到蓝牙数据:', arr);

			//             // 举例：收到特定数据（如第一个字节为1）自动拍照
			//             if (arr[0] === 1) {
			//                 this.takePhoto();
			//             }
			//         });

			//         uni.showToast({
			//             title: '蓝牙已开始读取',
			//             icon: 'success'
			//         });
			//     } catch (e) {
			//         uni.showToast({
			//             title: String(e),
			//             icon: 'none'
			//         });
			//     }
			// },




			openBluetoothAdapter() {
				return new Promise((resolve, reject) => {
					uni.openBluetoothAdapter({
						success(res) {
							console.log('蓝牙适配器初始化成功', res);
							resolve(res);
						},
						fail(err) {
							console.error('蓝牙适配器初始化失败', err);
							reject(err);
						}
					});
				});
			},

			// 获取附近蓝牙设备并连接
			getConnectedDevice() {
				return new Promise((resolve, reject) => {
					uni.getBluetoothDevices({
						success: (devicesRes) => {
							if (devicesRes.devices.length > 0) {
								const deviceId = devicesRes.devices[0].deviceId; // 假设我们连接第一个设备
								uni.createBLEConnection({
									deviceId: deviceId,
									success: (res) => {
										console.log('设备连接成功', res);
										resolve(deviceId); // 返回deviceId用于后续操作
									},
									fail: (err) => {
										console.error('连接蓝牙设备失败', err);
										reject(err);
									}
								});
							} else {
								reject("没有可用的蓝牙设备");
							}
						},
						fail: (err) => {
							console.error('扫描蓝牙设备失败', err);
							reject(err);
						}
					});
				});
			},

			// 获取设备服务并获取特征值
			getBluetoothServicesAndCharacteristics(deviceId) {
				return new Promise((resolve, reject) => {
					// 获取设备服务列表
					uni.getBLEDeviceServices({
						deviceId: deviceId,
						success: (servicesRes) => {
							if (servicesRes.services.length > 0) {
								const serviceId = servicesRes.services[0].uuid; // 假设选择第一个服务
								// 获取特征值列表
								uni.getBLEDeviceCharacteristics({
									deviceId: deviceId,
									serviceId: serviceId,
									success: (charRes) => {
										if (charRes.characteristics.length > 0) {
											const characteristicId = charRes
												.characteristics[0].uuid; // 假设选择第一个特征值
											resolve({
												deviceId,
												serviceId,
												characteristicId
											});
										} else {
											reject("没有可用的特征值");
										}
									},
									fail: (err) => {
										console.error('获取特征值失败', err);
										reject(err);
									}
								});
							} else {
								reject("没有可用的服务");
							}
						},
						fail: (err) => {
							console.error('获取服务失败', err);
							reject(err);
						}
					});
				});
			},



			readBleCharacteristicValue(deviceId, serviceId, characteristicId) {
				let th = this
				console.log('4444')
				// 1. 监听特征值变化（全局只监听一次即可）
				uni.onBLECharacteristicValueChange(function(res) {
					console.log(res)
					const arr = new Uint8Array(res.value);
					// 你可以把arr转为字符串，或按协议解析
					console.log('收到蓝牙read数据:', arr);
					// 这里可以做你要做的业务，比如调用拍照
				});

				// 2. 定时主动读取
				let bleReadTimer = setInterval(() => {
					uni.readBLECharacteristicValue({
						deviceId, // 已连接设备ID
						serviceId, // 你的serviceId
						characteristicId, // 支持read的characteristicId
						success() {
							// 真正的数据会通过上面 onBLECharacteristicValueChange 回调收到
						},
						fail(err) {
							console.error('读取失败', err);
						}
					});
				}, 1000); // 这里1秒轮询一次，你可以根据实际调整时间

				// 3. 页面关闭时别忘记清除定时器
				// clearInterval(bleReadTimer);

			},

			ab2str(buf) {

			},




			async takePhoto() {
				let th = this;
				try {
					// 使用 Promise 包装 takePhoto 以便支持 async/await
					const res = await new Promise((resolve, reject) => {
						this.cameraContext.takePhoto({
							quality: 'high',
							success: resolve, // 成功后执行 resolve，返回 res
							fail: reject // 失败时执行 reject
						});
					});

					console.log('拍照成功:', res.tempImagePath); // 成功后获取图片路径

					// 等待 mergeImages 操作完成
					let img = await th.mergeImages(res.tempImagePath);
					console.log(img);

					// 将处理后的图片路径推入 ListImags 数组
					th.ListImags.push(img.tempFilePath);

					console.log(th.ListImags)
				} catch (err) {
					console.error('拍照或处理图片失败:', err); // 捕获错误
				}
			},


			mergeImages(imgPath) {
				return new Promise((resolve, reject) => {
					if (!imgPath) {
						console.log("No image path provided.");
						reject("Image path is undefined or empty.");
						return;
					}

					uni.getImageInfo({
						src: imgPath,
						success: (res) => {
							// 获取图片的宽高
							const width = res.width;
							const height = res.height;
							const ctx = uni.createCanvasContext('myCanvas', this);

							// 获取图片的宽高比，裁剪成正方形
							const size = Math.min(width, height); // 选择宽和高的最小值作为正方形尺寸
							const offsetX = (width - size) / 2; // 计算裁剪起始点 X
							const offsetY = (height - size) / 2; // 计算裁剪起始点 Y
							// 绘制裁剪后的正方形图片
							ctx.drawImage(res.path, offsetX, offsetY, size, size, 0, 0, 300,
								300); // 裁剪成 1:1 比例并绘制在 canvas 上
							ctx.draw(false, () => {
								uni.canvasToTempFilePath({
									canvasId: 'myCanvas',
									success: (res) => {
										this.resultImage = res.tempFilePath;
										resolve({
											tempFilePath: res.tempFilePath,
											width: width, // 返回宽度
											height: height // 返回高度
										});
									},
									fail: (e) => {
										console.log(e);
										uni.showToast({
											title: '导出失败',
											icon: 'none'
										});
										reject(e);
									}
								}, this);
							});
						},
						fail: (err) => {
							console.log(err);
							uni.showToast({
								title: '图片加载失败',
								icon: 'none'
							});
							reject(err);
						}
					});
				});
			},


			getNotifyCharacteristicId(deviceId, serviceId) {
				return new Promise((resolve, reject) => {
					uni.getBLEDeviceCharacteristics({
						deviceId,
						serviceId,
						success: res => {
							// 找支持notify/indicate的特征值
							const char = res.characteristics.find(
								c => c.properties.notify || c.properties.indicate
							);
							if (char) {
								this.characteristicId = char.uuid;
								resolve(this.characteristicId);
							} else {
								reject('无可用notify特征值');
							}
						},
						fail: reject
					});
				});
			},






			unpType(e) {
				let th = this
				const mainIndex = e.detail.value[0];
				const subIndex = e.detail.value[1];
				const mainName = this.pickerRange[0][mainIndex];
				const subName = this.pickerRange[1][subIndex];
				this.selectedMain = mainName;
				this.selectedSub = subName;
				if (subName == undefined) {
					this.selectedMain = mainName
				}
				this.selectedMain = subName
				this.commodities.forEach((elenent, index) => {
					if (elenent.name == mainName) {
						elenent.children.forEach((elen, index) => {
							if (elen.name == subName) {
								th.categoryId = elen.id
							}
						})
						if (elenent.children.length == 0) {
							th.categoryId = elenent.id
							th.selectedMain = elenent.name
						}
					}
				})
				console.log(th.categoryId)
				// console.log('选中的主分类:', mainName);
				// console.log('选中的子分类:', subName);
			},
			showType(e) {
				this.showPicker = true
			},
			onChange(e) {
				const column = e.detail.column;
				const value = e.detail.value;

				// 如果是第一列变动（主分类）
				if (column === 0) {
					const mainIndex = value;

					// 更新二级分类数据
					const subCategories = this.commodities[mainIndex]?.children.map(child => child.name) || [];

					// 更新 pickerRange 第二列
					this.pickerRange[1] = subCategories;

					// 重设 pickerValue（保持第一列当前值，第二列归0）
					this.pickerValue = [mainIndex, 0];
				} else {
					// 如果是第二列变动，仅更新 pickerValue
					this.pickerValue[1] = value;
				}
			},
			onCancel(e) {
				this.showPicker = false;
				console.log('取消选择了分类');
			},
			async acategories() {
				let obj = {
					url: api.ctrl + suffixAddress.add().commodities,
				}
				let res = await request(obj)
				this.commodities = res.data // 假设你的数据在 res.data

				// 提取一级分类名
				const mainCategories = this.commodities.map(item => item.name)
				// 提取第一个一级分类的子分类名
				const subCategories = this.commodities[0]?.children.map(child => child.name) || []

				this.pickerRange = [mainCategories, subCategories]
			},
			remove(e) {
				// console.log(e)
				// this.qiniuyunImage.splice(e.index, 1);
				// console.log(this.qiniuyunImage)
			},
			async complete(e) {
				this.arrimgas = e.imageArr
			},
			async unpdflin() {
				let th = this;
				th.arrimgas = th.ListImags
				if (this.arrimgas.length == 0) {
					uni.showToast({
						title: '请上传图片',
						icon: 'error', // 可选值：success、loading、none
						duration: 1000 // 显示时长（单位：ms）
					});
					return
				} else if (th.arrcont[0].text == '') {
					// uni.showToast({
					// 	title: '请输入大小',
					// 	icon: 'error', // 可选值：success、loading、none
					// 	duration: 1000 // 显示时长（单位：ms）
					// });
					// return
				} else if (th.categoryId == null) {
					uni.showToast({
						title: '请输入分类',
						icon: 'error', // 可选值：success、loading、none
						duration: 1000 // 显示时长（单位：ms）
					});
					return
				} else if (th.moshidL == 0) {
					uni.showToast({
						title: '不能为0',
						icon: 'error', // 可选值：success、loading、none
						duration: 1000 // 显示时长（单位：ms）
					});
					return
				}
				if (th.sourceIndex == '') {
					uni.showToast({
						title: '请输入名称',
						icon: 'error', // 可选值：success、loading、none
						duration: 1000 // 显示时长（单位：ms）
					});
					return
				}




				uni.showLoading({
					title: '上传中...'
				});
				// 同时发起所有上传请求，并在所有完成后同步处理结果
				// 如果发现 filePath 总是同一个，建议使用传统 for 循环，确保每次迭代都获取正确的路径
				this.qiniuyunImage = []
				console.log(this.arrimgas)
				for (const filePath of this.arrimgas) {
					// 等待上一张上传完成才继续下一张
					let key = await this.Tokenqiniu(filePath)
					console.log('上传文件路径：', filePath)
					console.log('返回的 key：', key)
					this.qiniuyunImage.push(key)
				}
				this.UploadProducts()
			},
			async UploadProducts() {
				let th = this
				let arr = [{
					name: '',
					coverList: []
				}];

				let inputArray = this.qiniuyunImage;
				let groupSize = this.moshidL;

				let groupedData = [];

				// 将数据按 groupSize 大小进行分组
				for (let i = 0; i < inputArray.length; i += groupSize) {
					groupedData.push(inputArray.slice(i, i + groupSize));
				}
				const requests = []; // 用来存储每个请求的 Promise
				// 使用 for...of 代替 forEach 以便支持异步操作
				for (let index = 0; index < groupedData.length; index++) {
					const el = groupedData[index];
					let obj = {
						data: {
							"sourceIndex": this.sourceIndex,
							"desc": "",
							"categoryId": this.categoryId,
							"salePrice": '',
							"source": '1',
							"size": this.arrcont[0].text,
							"eyeletType": this.kouan[this.kouanIndex],
							"items": [{
								"name": this.sourceIndex + (index + 1) + 'P',
								"coverList": el
							}]
						},
						url: api.ctrl + '/commodities/batch',
						method: "POST",
					};

					console.log(obj); // 你可以把这个去掉，或者移到其他地方调试

					// 使用 Promise 来发送请求并将请求保存到数组
					const requestPromise = request(obj)
						.then(res => {
							console.log('请求成功:', res);
							return res;
						})
						.catch(err => {
							console.error('请求失败:', err);
							return err;
						});

					requests.push(requestPromise); // 保存 Promise 对象
				}

				// 等待所有请求完成
				try {
					const results = await Promise.all(requests);
					console.log('所有请求完成:', results);
				} catch (error) {
					console.error('部分请求出错:', error);
				}

				// 遍历输入数组，按chunkSize分组处理

				uni.hideLoading()
				uni.showToast({
					title: '上传成功',
					icon: 'success', // 可选值：success、loading、none
					duration: 1000 // 显示时长（单位：ms）
				});
				//商品图片变成空
				th.qiniuyunImage = []
				th.arrimgas = []
				th.ListImags = []
			},
			onSelectorChange(e) {
				this.selectedIndex = e.detail.value
			},
			mosadd(e) {
				this.mosIndex = e.detail.value
			},
			kouanadd(e) {
				this.kouanIndex = e.detail.value
			},
			fuzhis(sourceIndex) {
				if (sourceIndex == '') {
					uni.showToast({
						title: '不能复制空的',
						icon: 'error'
					});
					return
				}
				uni.setClipboardData({
					data: sourceIndex,
					success() {
						uni.showToast({
							title: '复制成功',
							icon: 'success'
						});
					}
				})
			}
		}
	}
</script>

<style lang="less">
	.shangc-box {
		background-color: #F5F5F5;
		padding-top: 40upx;
	}

	.shangc-neir {
		background-color: #fff;
		padding: 40upx;
		box-sizing: border-box;
		display: flex;
		width: 100vw;
		border-bottom: 1px solid #F5F5F5;

		>input {
			flex: 1;
			text-align: center;
		}
	}

	.imgasea {
		padding-left: 25rpx;
	}

	.unpdata {
		box-sizing: border-box;
		padding: 20rpx;
		margin: 20rpx;
		text-align: center;
		background: #FF9900;
		border-radius: 20rpx;
		font-size: 40rpx;
		// color: #F5F5F5;
	}

	.picker {
		display: flex;
	}

	.juzhong {
		width: 500rpx;
		text-align: center;
	}

	.image-grid {
		display: grid;
		grid-template-columns: repeat(3, 1fr);
		/* 每行显示 3 张图片 */
		gap: 10px;
		/* 设置图片间的间隙 */
		padding: 10px;
	}

	.grid-item {
		position: relative;
		display: flex;
		justify-content: center;
		align-items: center;
		overflow: hidden;
		/* 防止图片超出范围 */
		border-radius: 8px;
		/* 设置圆角 */
		box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
		/* 设置阴影 */
		height: 120px;
		/* 固定每个单元格的高度 */
		width: 120px;
		/* 固定每个单元格的宽度 */
	}

	image {
		width: 100%;
		height: 100%;
		object-fit: cover;
		/* 确保图片填充整个单元格 */
	}

	/* 删除按钮样式 */
	.delete-btn {
		position: absolute;
		top: 10px;
		right: 10px;
		background-color: rgba(0, 0, 0, 0.6);
		color: white;
		padding: 5px 10px;
		border-radius: 5px;
		cursor: pointer;
		font-size: 12px;
	}

	.delete-btn:hover {
		background-color: rgba(0, 0, 0, 0.8);
	}

	.camera-container {
		display: flex;
		justify-content: center;
		/* 水平居中 */
		align-items: center;
		/* 垂直居中 */
		margin-top: 20rpx;
	}
</style>